home *** CD-ROM | disk | FTP | other *** search
/ PC Media 22 / PC MEDIA CD22.iso / share / prog / datalib2 / datapriv.hpp < prev    next >
Text File  |  1995-08-14  |  7KB  |  198 lines
  1. // This is the header file for the database analysis package
  2.  
  3. // This file holds private functions, structures etc.
  4.  
  5. // Robin Abbott, 6/9/91
  6.  
  7. // Structure for a cluster in an index file
  8. // Related functions in the record file
  9.  
  10. #include "database.hpp"        // Universal includes
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <time.h>
  15. #include <ctype.h>
  16. #include <conio.h>
  17. #include <math.h>
  18. #include <io.h>
  19.  
  20. // Functions
  21.  
  22. int compnum(void *field,void *num);    // Compare field and number
  23.  
  24. //
  25. // indclus. This structure holds one index block from the NDX file
  26. // Note that several records may refer to the same indclus
  27. // and the nuse member holds a count of the number of times this cluster is
  28. // in use
  29. //
  30.  
  31. struct indclus
  32. {
  33.  struct indclus *parent;    // Pointer to parent of this cluster
  34.  struct indclus *next;        // Next indclus in list
  35.  struct indclus *prev;        // Previous indclus in list
  36.  int nuse;            // No. of times in use
  37.  int change;            // Flags this cluster has been changed
  38.  int valid;            // Cluster has not been deleted
  39.  char clusdat[512];        // Holds the cluster data
  40.  int nclusrec;            // Number of records in this cluster
  41.  int clustyp;            // Type of cluster, 0=record, 1=pointer
  42.  int reclen;            // Length of expr(rounded up to word)+pointers
  43.  int explen;            // Length of expression in cluster
  44.  index *oi;            // Owning index
  45.  FILE *fp;            // File pointer from which this was got
  46.  long clusn;            // Cluster number
  47.  
  48.  indclus(long nclus,indclus *parent,
  49.          index *oi);                // Construct
  50.  ~indclus();                    // Destructor
  51.  
  52.  struct indpt *findptr(int &rn);        // Find block pting to cluster
  53.  void subtract(int rn);                // Remove key
  54.  int add(char *nkey,long rn,int in,int rsk);    // Insert a key
  55.  int newkey(long kclus,char *nkey,long nclus);        // Replace key with new one
  56.  char *verclus(void (*progress)(int,long),int o);   // Verify a cluster tree
  57. };
  58.  
  59. //
  60. // The indpt structure holds a pointer to an indclus record. There is one of
  61. // these for each record which has an index, and the indpt structures form
  62. // a tree
  63. //
  64.  
  65. struct indpt
  66. {
  67.  indclus *icp;        // Points to associated indclus
  68.  indpt *parent;        // Parent of this indpt
  69.  int currec;        // Current record in indclus
  70.  
  71.  indpt(indclus *);                // Construct pointing to indclus
  72.  indpt(long nclus,indpt *parent,index *oi); // Construct with parent
  73.  ~indpt();                    // Destruct
  74.  
  75.  indpt *selkey(char *v,int n,int &r,int &i); // Construct & select by key
  76. };
  77.  
  78. // Structure for an index file
  79.  
  80. struct index
  81. {
  82.  char fname[128];    // 128 character filename
  83.  FILE *fp;        // File for this index
  84.  char name[10];        // Name of index without path or extension
  85.  index *next;        // next index on list
  86.  struct indclus *topind; // Pointer to current index tree, top cluster
  87.  int nclus;         // no. of index clusters attached
  88.  char indexp[128];     // Index expression
  89.  char tindexp[512];     // Tokenised index expression
  90.  int indtype;         // Index type, OPINT or OPSTR
  91.  char fclus[512];     // Holds 1st cluster of index file
  92.  long tblk;         // top block of tree
  93.  long lblk;         // last block of tree
  94.  int chng;         // index 1st cluster has changed flag
  95.  int maxclusrec;     // Max. no. of records/cluster
  96.  record *firstrec;     // Points to records using this index
  97.  int restype;        // Result type, OPINT,OPSTR or OPDATE
  98.  
  99.  ~index();         // delete, updating fclus & writing if necessary
  100. };
  101.  
  102.  
  103. #define DBSIZE     32      // Size of a database file definition record
  104. #define INDLEN     18      // Position of index record length in index file
  105. #define INDELEN 12
  106. #define INDEXP  24      // Index expression offset
  107. #define INDTYPE 16      // Index result type
  108. #define DATEOFF 1721045L  // Offset of date added in dBASE
  109.  
  110. void fputi(int i,FILE *fp);    // Put an integer to file
  111. void fputl(long l,FILE *fp);    // Put a long to a file
  112.  
  113. /***************************************************************************
  114.  
  115.  Here comes all the stuff concerned with evaluating expressions
  116.  
  117. ****************************************************************************/
  118.  
  119. /* Header file for expression evaluator, modify as required */
  120.  
  121. /* Structures used by the program */
  122.  
  123. struct    opinf        // Information on an operator
  124. {
  125.  char    lit[10];    // Literal string representing the operator
  126.  int    type;        // Type of operator
  127.  int    pri;        // Priority of binary operator
  128.  int    type1;        // Type of 1st (or only) operand
  129.  int     type2;        // Type of 2nd operand (binary only)
  130.  int    optype;        // Result of operator
  131.  int    num;        // Number of operator
  132. };
  133.  
  134. struct op      // An operand structure
  135. {
  136.  int    optype;   // Type of operand, 1=int, 2=string, 4=Date, 8=Logical
  137.  int     oplen;      // Length of result for string in index checking
  138.  union
  139.  {
  140.   double    num;        // Return value, number
  141.   char       *str;        // Return address of string
  142.   char        date[9];    // Date string
  143.  };
  144. };
  145.  
  146. class expval
  147. {
  148.  struct op retop;                  // Value returned from evaluator
  149.  char     *exwork;             // Evaluator work space pointer
  150.  char    *exworkp;             // Points to next free space in exwork
  151.  database *db;                 // Points to owner database
  152.  
  153.  int    exescan(char **,int f=0);            //  Scan for next character 
  154.  int    exegetop(int c,char **s);        // Try to find an operator
  155.  op     *evalstr(char **,int,record *rp);   // Evaluate a tokenised string
  156.  char    *exealloc(int);                // Allocate some work space 
  157.  void    execomp(struct op*,struct op*,int); // Comparison Routine
  158.  void   plumin(struct op*, struct op*,int); // Handle plus/minus
  159.  void   exestr(struct op*,int sint,
  160.                struct op*,int type);        // Handle Left,right,substr
  161.  
  162.  public:
  163.  
  164.  // Common routines and variables
  165.  
  166.  int erflag;         // An error occurred on expression evaluation
  167.  
  168.  expval(database *db);    // Initialisation routine
  169.  ~expval();
  170.  
  171.  int    exeinput(char*,int);        // Input routine
  172.  char   *exetoken(char *,char **);      // Tokeniser routine
  173.  op     *exeval(char **,record *rp);    // Evaluate a string
  174.  long    days(char *date);        // Convert string to days since 0
  175.  char     *cdow(char *date);            // day of week (character)
  176.  char   *cmonth(char *date);            // Month (character)
  177.  void   daystodate(char *date,long days);    // days to date
  178.  void   ctod(char *date,char *s);        // String to date
  179.  int    dow(char *date);            // day of week (numeric)
  180.  
  181.  // User supplied routines
  182.  
  183.  void    err(char *);                 // Recoverable error
  184.  void    errfatal(char *s);
  185. };
  186.  
  187.  
  188. /*
  189.    Expression Evaluator.
  190.    Internal Buffer Sizes, Only modify if program crashes out with
  191.    a memory error.
  192. */
  193.  
  194.  
  195. #define EXWORKSIZE    1024        // Size of evaluator work space
  196.  
  197. #include "exop.hpp"
  198.